package com.leetcode.algorithm.topic;

import com.leetcode.algorithm.common.TreeNode;

/**
 * 二叉搜索树相关算法题解
 * 二叉搜索树的特性:
 * 	1.二叉搜索树的中序遍历是有序序列
 * (done)700. 二叉搜索树中的搜索
 * (done)701. 二叉搜索树中的插入操作
 * (done)450. 删除二叉搜索树中的节点
 * (done)1008. 先序遍历构造二叉树
 * (done)98. 验证二叉搜索树
 * 
 * @author: jie.deng
 * @time: 2019年3月26日 下午7:38:25
 */
public class BinarySearchTreeSolution {
	/**
     * 700. 二叉搜索树中的搜索
     * 
     * 给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。
     * 
     * 例如，
     * 
     * 给定二叉搜索树:
     * 
     *         4
     *        / \
     *       2   7
     *      / \
     *     1   3
     * 
     * 和值: 2
     * 你应该返回如下子树:
     * 
     *       2     
     *      / \   
     *     1   3
     * 在上述示例中，如果要找的值是 5，但因为没有节点值为 5，我们应该返回 NULL。
     * @param root
     * @param val
     * @return
     */
	public TreeNode searchBST(TreeNode root, int val) {
		if (root == null) {
			return null;
		}
		TreeNode cur = root;
		while (cur != null && cur.val != val) {
			if (cur.val > val) {
				cur = cur.left;
			} else if (cur.val < val) {
				cur = cur.right;
			}
		}
		return (cur == root && cur.val != val) ? null : cur;
	}
	
	/**
	 * 701. 二叉搜索树中的插入操作
	 * 
     * 给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 保证原始二叉搜索树中不存在新值。
     * 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回任意有效的结果。
     * 例如, 
     * 
     * 给定二叉搜索树:
     * 
     *         4
     *        / \
     *       2   7
     *      / \
     *     1   3
     * 
     * 和 插入的值: 5
     * 你可以返回这个二叉搜索树:
     * 
     *          4
     *        /   \
     *       2     7
     *      / \   /
     *     1   3 5
     * 或者这个树也是有效的:
     * 
     *          5
     *        /   \
     *       2     7
     *      / \   
     *     1   3
     *          \
     *           4
	 * @param root
	 * @param val
	 * @return
	 */
	public TreeNode insertIntoBST(TreeNode root, int val) {
		TreeNode keyNode = new TreeNode(val);
		if (root == null) {
			return keyNode;
		}
		TreeNode cur = root;
		TreeNode pre = null; // 记录待插入结点的父结点
		while (cur != null && cur.val != val) {
			pre = cur;
			if (cur.val > val) {
				cur = cur.left;
			} else if (cur.val < val) {
				cur = cur.right;
			}
		}
		if (cur == null) { // 说明cur.val != val，原始二叉搜索树中不存在新值
			if (pre.val > val) {
				pre.left = keyNode;
			} else if (pre.val < val) {
				pre.right = keyNode;
			}
		}
		return root;
	}
	
    /**
     * 1008. 先序遍历构造二叉树
     * 
     * 返回与给定先序遍历 preorder 相匹配的二叉搜索树（binary search tree）的根结点。
     * (回想一下，二叉搜索树是二叉树的一种，其每个节点都满足以下规则，对于 node.left 的任何后代，值总 < node.val，而 node.right 的任何后代，值总 > node.val。此外，先序遍历首先显示节点的值，然后遍历 node.left，接着遍历 node.right。）
     * 
     * 示例：
     * 
     * 输入：[8,5,1,7,10,12]
     * 输出：[8,5,10,1,7,null,12]
     * 
     * 提示：
     * 
     * 1 <= preorder.length <= 100
     * 先序 preorder 中的值是不同的。
     * @param preorder
     * @return
     */
	public TreeNode bstFromPreorder2(int[] preorder) {
		if (preorder == null || preorder.length == 0) {
			return null;
		}
		TreeNode root = null;
		for (int num : preorder) {
			root = insertIntoBST(root, num);
		}
		return root;
	}

    /**
     * 450. 删除二叉搜索树中的节点
     * 
     * 给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。
     * 一般来说，删除节点可分为两个步骤：
     * 首先找到需要删除的节点；
     * 如果找到了，删除它。
     * 说明： 要求算法时间复杂度为 O(h)，h 为树的高度。
     * 
     * 示例:
     * 
     * root = [5,3,6,2,4,null,7]
     * key = 3
     * 
     *     5
     *    / \
     *   3   6
     *  / \   \
     * 2   4   7
     * 
     * 给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。
     * 
     * 一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。
     * 
     *     5
     *    / \
     *   4   6
     *  /     \
     * 2       7
     * 
     * 另一个正确答案是 [5,2,6,null,4,null,7]。
     * 
     *     5
     *    / \
     *   2   6
     *    \   \
     *     4   7
     * @param root
     * @param key
     * @return
     */
	public TreeNode deleteNode(TreeNode root, int key) {
		if (root == null) {
			return null;
		}
		TreeNode keyNode = null; // key对应的结点
		TreeNode parentNode = null; // keyNode的父结点
		TreeNode cur = root;
		while (cur != null && cur.val != key) {
			parentNode = cur;
			if (cur.val > key) {
				cur = cur.left;
			} else if (cur.val < key) {
				cur = cur.right;
			}
		}
		keyNode = (cur == root && cur.val != key) ? null : cur;
		if (keyNode == null) {
			// 没找到待删除的结点
			return root;
		}

		TreeNode newKey = null; // 用来替换待删除的结点
		if (keyNode.left == null || keyNode.right == null) {
			// 待删除的结点 只有左孩子结点 或者 只有右孩子结点 或者 没有孩子结点 的情况 : 以孩子结点替换待删除的结点
			newKey = keyNode.left == null ? keyNode.right : keyNode.left; // childNode为keyNode的孩子结点，可能为null
		} else {
			// 待删除的结点 有左孩子和右孩子
			// 以左孩子的最大结点替换掉待删除的结点
			cur = keyNode.left;
			TreeNode pre = null;
			while (cur.right != null) {
				pre = cur;
				cur = cur.right;
			}
			newKey = cur;
			if (pre != null) {
				pre.right = null; // 找到了左孩子的最大结点,解除其与父结点的关系
			}
			newKey.right = keyNode.right; // keyNode的right孩子结点作为maxLeft的右孩子

			cur = newKey;
			while (cur != keyNode.left && cur.left != null) {
				cur = cur.left;
			}
			if (cur != keyNode.left) {
				cur.left = keyNode.left; // keyNode的left孩子结点作为 maxLeft的最左孩子
			}
		}
		if (parentNode == null) {
			return newKey;
		} else if (parentNode.val < key) {
			// 待删除的结点为parentNode的右孩子结点
			parentNode.right = newKey;
		} else if (parentNode.val > key) {
			parentNode.left = newKey;
		}
		return root;
	}	
	

	/**
     * 98. 验证二叉搜索树
     * 
     * 给定一个二叉树，判断其是否是一个有效的二叉搜索树。
     * 
     * 假设一个二叉搜索树具有如下特征：
     * 
     * 节点的左子树只包含小于当前节点的数。
     * 节点的右子树只包含大于当前节点的数。
     * 所有左子树和右子树自身必须也是二叉搜索树。
     * 示例 1:
     * 
     * 输入:
     *     2
     *    / \
     *   1   3
     * 输出: true
     * 示例 2:
     * 
     * 输入:
     *     5
     *    / \
     *   1   4
     *      / \
     *     3   6
     * 输出: false
     * 解释: 输入为: [5,1,4,null,null,3,6]。
     *      根节点的值为 5 ，但是其右子节点值为 4 。
     * @param root
     * @return
     */
	public boolean isValidBST(TreeNode root) {
		if (root == null) {
			return true;
		}
		return isValidBST(root.left, null, root.val) && isValidBST(root.right, root.val, null);
	}

	private boolean isValidBST(TreeNode node, Integer min, Integer max) {
		if (node == null) {
			return true;
		}
		return (min == null || node.val > min) && (max == null || node.val < max)
				&& isValidBST(node.left, min, node.val) && isValidBST(node.right, node.val, max);
	}
	
    /**
     * 235. 二叉搜索树的最近公共祖先
     * 
     * 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
     * 
     * 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
     * 
     * 例如，给定如下二叉搜索树:  root = [6,2,8,0,4,7,9,null,null,3,5]
     * 示例 1:
     * 
     * 输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
     * 输出: 6 
     * 解释: 节点 2 和节点 8 的最近公共祖先是 6。
     * 示例 2:
     * 
     * 输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
     * 输出: 2
     * 解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。
     *  
     * 
     * 说明:
     * 
     * 所有节点的值都是唯一的。
     * p、q 为不同节点且均存在于给定的二叉搜索树中。
     * @param root
     * @param p
     * @param q
     * @return
     */
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        int min = p.val;
        int max = q.val;
        if (q.val < p.val) {
            min = q.val;
            max = p.val;
        }
        TreeNode node = root;
        while (node == null || node.val > max || node.val < min) {
            if (node.val > max) {
                node = node.left;
            } else if (node.val < min) {
                node = node.right;
            }
        }
        return node;
    }

    /**
     * 220. 存在重复元素 III
     * 
     * 给定一个整数数组，判断数组中是否有两个不同的索引 i 和 j，使得 nums [i] 和 nums [j] 的差的绝对值最大为 t，并且 i 和 j 之间的差的绝对值最大为 ķ。
     * 
     * 示例 1:
     * 
     * 输入: nums = [1,2,3,1], k = 3, t = 0
     * 输出: true
     * 示例 2:
     * 
     * 输入: nums = [1,0,1,1], k = 1, t = 2
     * 输出: true
     * 示例 3:
     * 
     * 输入: nums = [1,5,9,1,5,9], k = 2, t = 3
     * 输出: false
     * @param nums
     * @param k
     * @param t
     * @return
     */
    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
        if (nums == null || nums.length < 2 || k <= 0) {
            return false;
        }
        TreeNode root = new TreeNode(nums[0]);
        for (int idx = 1; idx < nums.length && idx <= k; idx++) {
            int val = nums[idx];
            if (!insertIntoBST(root, val, t)) {
                return true;
            }
        }
        for (int idx = k + 1; idx < nums.length; idx++) {
            int val = nums[idx];
            root = deleteNode(root, nums[idx - k - 1]);
            if (!insertIntoBST(root, val, t)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 在二叉搜索树中插入结点
     * 
     * @param root
     * @param val
     * @param t
     * @return 如果待插入的结点 val与树中结点的差的绝对值 <= t，则不插入数据返回false；其他情况插入并返回true
     */
    private boolean insertIntoBST(TreeNode root, int val, int t) {
        TreeNode node = new TreeNode(val); // 新结点
        TreeNode pre = null;
        TreeNode cur = root;
        while (cur != null && Math.abs((long) val - (long) cur.val) > (long) t) {
            pre = cur;
            if (cur.val > val) {
                cur = cur.left;
            } else {
                cur = cur.right;
            }
        }
        if (cur == null) {
            // 叶子结点，作为pre的孩子结点插入到树中
            if (pre.val > val) {
                pre.left = node;
            } else {
                pre.right = node;
            }
            return true;
        }
        return false;
    }
}